const config = require('../../utils/config')
const api = require('../../utils/api')

Page({
  data: {
    userInfo: {},
    hasLogin: false,
    loadingUserInfo: false,
    showLoginOptions: false,
    loginStep: 'select', // 登录步骤：select-选择登录方式, phone-手机号登录, wx-phone-微信授权手机号
    phone: '', // 手机号
    code: '', // 验证码
    codeSent: false, // 验证码是否已发送
    countDown: 60, // 验证码倒计时
    wxUserInfo: null, // 微信用户信息临时存储
    orderTabs: [
      {
        id: 'pending',
        name: '待付款',
        icon: '/static/images/icons/pending.png'
      },
      {
        id: 'delivery',
        name: '待发货',
        icon: '/static/images/icons/delivery.png'
      },
      {
        id: 'completed',
        name: '已完成',
        icon: '/static/images/icons/completed.png'
      },
      {
        id: 'canceled',
        name: '已取消',
        icon: '/static/images/icons/canceled.png'
      }
    ],
    // 最近3条订单摘要
    recentOrders: [],
    loadingOrders: false,
    showPhoneAuth: false, // 是否显示手机号授权弹窗
    showPhoneAuthPopup: false,
    avatarLoading: false, // 头像加载状态
    imageUrls: {
      phoneAuth: '/static/images/phone-auth.png',
      security: '/static/images/icon-security.png',
      service: '/static/images/icon-service.png',
      notify: '/static/images/icon-notify.png',
      wechat: '/static/images/wechat.png'
    },
    config: {}
  },
  
  onLoad() {
    console.log('页面加载，检查登录状态');
    
    // 获取全局数据
    const app = getApp();
    this.setData({ 
      config: app.globalData.config
    });
    
    // 加载图片资源
    this.loadImages();
    
    // 检查登录状态
    this.checkLoginStatus();
  },
  
  onShow() {
    this.checkLoginStatus();
    console.log('[onShow] 当前登录状态:', this.data.hasLogin);
    console.log('[onShow] 当前用户信息:', this.data.userInfo);
    
    // 更新tabBar选中状态
    if (typeof this.getTabBar === 'function') {
      this.getTabBar().setData({
        selected: 3
      });
    }
    
    // 如果已登录，加载最近订单
    if (this.data.hasLogin) {
      this.loadRecentOrders();
    }
  },
  
  // 检查登录状态
  checkLoginStatus() {
    // 检查是否登录
    const token = wx.getStorageSync('token');
    const userInfo = wx.getStorageSync('userInfo');
    
    console.log('当前登录状态：', {
      token: !!token,
      userInfo: userInfo || null
    });
    
    if (token && userInfo) {
      console.log('用户已登录', userInfo);
      this.setData({ 
        hasLogin: true,
        userInfo
      });
      
      // 调试输出头像信息
      if (userInfo.avatar) {
        console.log('头像URL:', userInfo.avatar);
      } else {
        console.log('用户信息中无头像URL');
      }
    }
  },
  
  // 获取用户信息
  getUserInfo() {
    // 模拟获取用户信息
    const userInfo = {
      nickname: '测试用户',
      avatar: '/static/images/default-avatar.png'
    }
    
    this.setData({
      userInfo: userInfo,
      hasLogin: true
    })
    
    // 保存到本地存储
    wx.setStorageSync('userInfo', userInfo)
    
    /*
    // 真实API调用，连接后端时取消注释
    api.get(config.API.USER.INFO)
      .then(res => {
        if (res.data) {
          this.setData({
            userInfo: res.data,
            hasLogin: true
          })
          wx.setStorageSync('userInfo', res.data)
        }
      })
      .catch(err => {
        console.error('获取用户信息失败', err)
        wx.removeStorageSync('token')
        wx.removeStorageSync('userInfo')
        this.setData({
          hasLogin: false,
          userInfo: {}
        })
      })
    */
  },
  
  // 加载最近订单
  loadRecentOrders() {
    // 设置加载状态
    this.setData({ ordersLoading: true });
    
    const url = config.API.ORDER.LIST + '/recent';
    
    api.get(url)
      .then(res => {
        if (res.code === 0 || res.code === 200) {
          this.setData({
            recentOrders: res.data || [],
            ordersLoading: false // 加载完成，隐藏加载图标
          });
        } else {
          console.error('获取订单失败:', res.message);
          this.setData({ 
            ordersLoading: false, // 加载失败也需要隐藏加载图标
            recentOrders: [] 
          });
        }
      })
      .catch(err => {
        console.error('加载订单错误:', err);
        this.setData({ 
          ordersLoading: false, // 出错也需要隐藏加载图标
          recentOrders: [] 
        });
      });
  },
  
  // 点击登录
  onLoginTap() {
    wx.navigateTo({
      url: '/pages/login/index'
    });
  },
  
  // 显示登录弹窗
  showLoginModal() {
    this.setData({
      showLoginOptions: true,
      loginStep: 'select',
      phone: '',
      code: '',
      codeSent: false,
      wxUserInfo: null
    });
  },
  
  // 隐藏登录弹窗并重置状态
  hideLoginModal() {
    this.setData({
      showLoginOptions: false,
      loginStep: 'select',
      phone: '',
      code: '',
      codeSent: false,
      wxUserInfo: null
    });
    
    // 清除定时器
    if (this.countDownTimer) {
      clearInterval(this.countDownTimer);
      this.countDownTimer = null;
    }
  },
  
  // 选择手机号登录
  selectPhoneLogin() {
    this.setData({
      loginStep: 'phone'
    });
  },
  
  // 返回登录选择
  backToLoginSelect() {
    this.setData({
      loginStep: 'select',
      phone: '',
      code: '',
      codeSent: false
    });
    
    // 清除定时器
    if (this.countDownTimer) {
      clearInterval(this.countDownTimer);
      this.countDownTimer = null;
    }
  },
  
  // 输入手机号
  onPhoneInput(e) {
    this.setData({
      phone: e.detail.value
    });
  },
  
  // 输入验证码
  onCodeInput(e) {
    this.setData({
      code: e.detail.value
    });
  },
  
  // 发送验证码
  sendVerifyCode() {
    const { phone } = this.data;
    
    // 手机号验证
    if (!/^1[3-9]\d{9}$/.test(phone)) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      });
      return;
    }
    
    // 发送验证码
    wx.showLoading({
      title: '发送中...',
    });
    
    // 调用发送验证码接口
    wx.request({
      url: 'http://localhost:3000/api/miniapp/users/send-code',
      method: 'POST',
      data: {
        phone: phone
      },
      success: (res) => {
        wx.hideLoading();
        
        if (res.data && res.data.code === 200) {
          // 验证码发送成功
          wx.showToast({
            title: '验证码已发送',
            icon: 'success'
          });
          
          // 开始倒计时
          this.setData({
            codeSent: true,
            countDown: 60
          });
          
          this.startCountDown();
        } else {
          // 验证码发送失败
          wx.showToast({
            title: res.data?.message || '验证码发送失败',
            icon: 'none'
          });
          
          // 模拟发送成功（仅用于开发测试）
          this.mockSendCode();
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('发送验证码失败:', err);
        
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
        
        // 模拟发送成功（仅用于开发测试）
        this.mockSendCode();
      }
    });
  },
  
  // 模拟发送验证码（仅用于开发测试）
  mockSendCode() {
    // 开始倒计时
    this.setData({
      codeSent: true,
      countDown: 60
    });
    
    this.startCountDown();
    
    wx.showToast({
      title: '验证码已发送(模拟)',
      icon: 'success'
    });
  },
  
  // 开始倒计时
  startCountDown() {
    // 清除可能存在的定时器
    if (this.countDownTimer) {
      clearInterval(this.countDownTimer);
    }
    
    this.countDownTimer = setInterval(() => {
      const { countDown } = this.data;
      
      if (countDown <= 1) {
        // 倒计时结束
        clearInterval(this.countDownTimer);
        this.countDownTimer = null;
        
        this.setData({
          codeSent: false,
          countDown: 60
        });
      } else {
        // 继续倒计时
        this.setData({
          countDown: countDown - 1
        });
      }
    }, 1000);
  },
  
  // 手机号登录
  phoneLogin() {
    const { phone, code } = this.data;
    
    // 手机号和验证码验证
    if (!/^1[3-9]\d{9}$/.test(phone)) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      });
      return;
    }
    
    if (!/^\d{6}$/.test(code)) {
      wx.showToast({
        title: '请输入6位数验证码',
        icon: 'none'
      });
      return;
    }
    
    // 登录
    wx.showLoading({
      title: '登录中...',
    });
    
    // 调用登录接口
    wx.request({
      url: 'http://localhost:3000/api/miniapp/users/phone-login',
      method: 'POST',
      data: {
        phone: phone,
        code: code
      },
      success: (res) => {
        wx.hideLoading();
        
        if (res.data && res.data.code === 200) {
          // 登录成功
          const { token, user } = res.data.data;
          
          // 保存token和用户信息
          wx.setStorageSync('token', token);
          wx.setStorageSync('userInfo', user);
          
          // 更新页面状态
          this.setData({
            hasLogin: true,
            userInfo: user
          });
          
          // 关闭登录弹窗
          this.hideLoginModal();
          
          wx.showToast({
            title: '登录成功',
            icon: 'success'
          });
        } else {
          // 登录失败
          wx.showToast({
            title: res.data?.message || '登录失败',
            icon: 'none'
          });
          
          // 模拟登录成功（仅用于开发测试）
          this.mockPhoneLogin();
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('登录失败:', err);
        
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
        
        // 模拟登录成功（仅用于开发测试）
        this.mockPhoneLogin();
      }
    });
  },
  
  // 模拟手机号登录（仅用于开发测试）
  mockPhoneLogin() {
    // 随机生成用户ID
    const randomId = Math.floor(Math.random() * 1000000);
    
    // 模拟用户数据
    const userInfo = {
      id: randomId,
      nickname: '手机用户' + this.data.phone.substr(-4),
      avatar: '/static/images/default-avatar.png',
      phone: this.data.phone,
      status: 1
    };
    
    // 模拟token
    const token = 'mock_token_phone_' + Date.now();
    
    // 保存到本地存储
    wx.setStorageSync('token', token);
    wx.setStorageSync('userInfo', userInfo);
    
    // 更新页面状态
    this.setData({
      hasLogin: true,
      userInfo: userInfo
    });
    
    // 关闭登录弹窗
    this.hideLoginModal();
    
    wx.showToast({
      title: '登录成功(模拟)',
      icon: 'success'
    });
  },
  
  // 使用wx.getUserProfile获取用户信息
  getUserProfile() {
    console.log('[getUserProfile] 开始获取用户信息');
    
    this.setData({
      avatarLoading: true
    });
    
    wx.getUserProfile({
      desc: '用于完善会员资料',
      success: (res) => {
        console.log('[getUserProfile] 获取用户信息成功', res);
        
        try {
          // 提取用户信息
          const wxUserInfo = res.userInfo;
          console.log('[getUserProfile] 提取的微信用户信息', wxUserInfo);
          
          // 准备将微信返回的信息转换为我们的用户信息格式
          const userInfo = {
            nickname: wxUserInfo.nickName,
            avatar: wxUserInfo.avatarUrl, // 微信返回的是avatarUrl，我们存储为avatar
            gender: wxUserInfo.gender
          };
          
          // 检查头像URL
          if (userInfo.avatar) {
            console.log('[getUserProfile] 获取到的头像URL:', userInfo.avatar);
            
            // 确保微信头像URL是https协议 (有时候微信返回的是http)
            if (userInfo.avatar.startsWith('http:')) {
              userInfo.avatar = userInfo.avatar.replace('http:', 'https:');
              console.log('[getUserProfile] 头像URL转换为https:', userInfo.avatar);
            }
          } else {
            console.warn('[getUserProfile] 未获取到头像URL');
          }
          
          // 执行微信登录流程
          this.wxLogin(userInfo);
        } catch (error) {
          console.error('[getUserProfile] 处理用户信息时出错', error);
          this.setData({
            avatarLoading: false
          });
          wx.showToast({
            title: '获取用户信息失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.log('[getUserProfile] 获取用户信息失败', err);
        this.setData({
          avatarLoading: false
        });
        wx.showToast({
          title: '已取消授权',
          icon: 'none'
        });
      }
    });
  },
  
  // 微信登录流程
  wxLogin(userInfo) {
    console.log('[wxLogin] 开始微信登录', userInfo);
    
    // 获取登录code
    wx.login({
      success: async (res) => {
        if (res.code) {
          // 将用户信息和code一起传给后台
          try {
            console.log('[wxLogin] 获取到code:', res.code);
            console.log('[wxLogin] 准备请求后端登录接口');
            
            // 使用真实API调用，不再使用模拟登录
            this.setData({ avatarLoading: true });
            
            wx.request({
              url: 'http://localhost:3000/api/miniapp/users/wx-login',
              method: 'POST',
              data: {
                code: res.code,
                userInfo: {
                  nickname: userInfo.nickname || '微信用户',
                  avatar: userInfo.avatar,
                  gender: userInfo.gender || 0
                }
              },
              success: (loginRes) => {
                console.log('[wxLogin] 登录接口响应:', loginRes.data);
                this.setData({ avatarLoading: false });
                
                if (loginRes.statusCode === 200 && loginRes.data.code === 200) {
                  // 登录成功
                  const { token, user } = loginRes.data.data;
                  
                  // 保存token和用户信息
                  wx.setStorageSync('token', token);
                  wx.setStorageSync('userInfo', user);
                  
                  // 更新页面状态
                  this.setData({
                    hasLogin: true,
                    userInfo: user,
                    showLoginOptions: false, // 关闭登录弹窗
                    avatarLoading: false
                  });
                  
                  wx.showToast({
                    title: '登录成功',
                    icon: 'success'
                  });
                  
                  // 如果用户未绑定手机号，显示手机号授权弹窗
                  if (!user.phone) {
                    setTimeout(() => {
                      this.showPhoneAuth();
                    }, 1000);
                  }
                } else {
                  // 登录失败
                  wx.showToast({
                    title: loginRes.data?.message || '登录失败',
                    icon: 'none'
                  });
                  
                  // 如果后端接口失败，才使用模拟登录（仅开发环境）
                  if (process.env.NODE_ENV === 'development') {
                    this.mockLogin(userInfo);
                  }
                }
              },
              fail: (error) => {
                console.error('[wxLogin] 请求失败:', error);
                this.setData({ avatarLoading: false });
                
                wx.showToast({
                  title: '网络请求失败',
                  icon: 'none'
                });
                
                // 如果网络请求失败，才使用模拟登录（仅开发环境）
                if (process.env.NODE_ENV === 'development') {
                  this.mockLogin(userInfo);
                }
              }
            });
            
          } catch (error) {
            console.error('[wxLogin] 登录失败:', error);
            this.setData({
              avatarLoading: false
            });
            wx.showToast({
              title: '登录失败，请重试',
              icon: 'none'
            });
          }
        } else {
          console.error('[wxLogin] 获取code失败:', res.errMsg);
          this.setData({
            avatarLoading: false
          });
          wx.showToast({
            title: '登录失败，请重试',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('[wxLogin] wx.login失败:', err);
        this.setData({
          avatarLoading: false
        });
        wx.showToast({
          title: '登录失败，请重试',
          icon: 'none'
        });
      }
    });
  },
  
  // 获取微信绑定的手机号
  getPhoneNumber(e) {
    if (e.detail.errMsg === 'getPhoneNumber:ok') {
      const { encryptedData, iv } = e.detail;
      // 调用服务器API获取手机号
      wx.showLoading({
        title: '授权中...',
      });
      
      // 模拟API调用
      setTimeout(() => {
        wx.hideLoading();
        wx.showToast({
          title: '授权成功',
          icon: 'success'
        });
        this.setData({
          showPhoneAuth: false
        });
        // 获取用户信息
        this.getUserInfo();
      }, 1500);
    } else {
      wx.showToast({
        title: '授权失败',
        icon: 'none'
      });
    }
  },
  
  // 显示手机号授权弹窗
  showPhoneAuth() {
    this.loadImages(); // 确保图片已加载
    this.setData({
      showPhoneAuthPopup: true
    });
  },
  
  // 关闭手机号授权弹窗
  onClosePhoneAuth() {
    this.setData({
      showPhoneAuthPopup: false
    });
  },
  
  // 跳过手机号授权
  skipPhoneAuth() {
    this.setData({
      showPhoneAuthPopup: false
    });
  },
  
  // 模拟登录成功（仅用于开发测试）
  mockLogin(userInfo) {
    console.log('[mockLogin] 模拟登录成功', userInfo);
    
    // 使用微信授权获取的用户信息构造模拟用户数据
    // 确保微信返回的头像URL能够正确使用
    const mockUser = {
      id: 'mock_user_' + Date.now(),
      openid: 'mock_openid_' + Date.now(),
      nickname: userInfo.nickname || '微信用户',
      avatar: userInfo.avatar || 'https://thirdwx.qlogo.cn/mmopen/vi_32/Q0j4TwGTfTI/132',
      gender: userInfo.gender || 1,
      phone: '',
      created_at: new Date().toISOString()
    };
    
    console.log('[mockLogin] 生成的模拟用户信息:', mockUser);
    
    // 模拟token
    const mockToken = 'mock_token_' + Date.now();
    
    // 保存到本地
    wx.setStorageSync('token', mockToken);
    wx.setStorageSync('userInfo', mockUser);
    
    // 更新页面状态
    this.setData({
      hasLogin: true,
      userInfo: mockUser,
      showLoginOptions: false // 关闭登录弹窗
    });
    
    wx.showToast({
      title: '模拟登录成功',
      icon: 'success'
    });
    
    // 如果用户未绑定手机号，显示手机号授权弹窗
    setTimeout(() => {
      this.showPhoneAuth();
    }, 1000);
  },
  
  // 退出登录
  logout: function() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除本地存储的用户信息和登录状态
          wx.removeStorageSync('userInfo');
          wx.removeStorageSync('token');
          
          // 更新当前页面数据状态
          this.setData({
            userInfo: null,
            hasUserInfo: false,
            hasLogin: false,
            openid: ''
          });
          
          wx.showToast({
            title: '已退出登录',
            icon: 'success'
          });
        }
      }
    });
  },
  
  // 跳转到订单页面
  goToOrder(e) {
    const type = e.currentTarget.dataset.type;
    // 检查登录状态
    if (!this.data.hasLogin) {
      this.showLoginModal();
      return;
    }
    
    console.log('跳转到订单页面, 类型:', type);
    
    wx.navigateTo({
      url: '/pages/order/index?type=' + type
    });
  },
  
  // 查看订单详情
  viewOrderDetail(e) {
    // 检查登录状态
    if (!this.data.hasLogin) {
      this.showLoginModal();
      return;
    }
    
    const orderId = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/order/detail/index?id=${orderId}`
    });
  },
  
  // 跳转到地址管理
  goToAddress() {
    // 检查登录状态
    if (!this.data.hasLogin) {
      this.showLoginModal();
      return;
    }
    
    wx.navigateTo({
      url: '/pages/address/index'
    });
  },
  
  // 跳转到收藏页
  goToFavorite() {
    // 检查登录状态
    if (!this.data.hasLogin) {
      this.showLoginModal();
      return;
    }
    
    wx.navigateTo({
      url: '/pages/favorite/index'
    });
  },
  
  // 跳转到设置页
  goToSettings() {
    wx.navigateTo({
      url: '/pages/settings/index'
    });
  },

  // 跳转到首页
  goToIndex() {
    // 使用switchTab可以跳转到tabBar页面
    wx.switchTab({
      url: '/pages/index/index'
    });
  },

  // 加载本地图片资源
  loadImages() {
    this.setData({
      imageUrls: {
        phoneAuth: '/static/images/icons/phone-auth.png',
        security: '/static/images/icons/security.png',
        service: '/static/images/icons/service.png',
        notify: '/static/images/icons/notify.png',
        wechat: '/static/images/icons/wechat.png'
      }
    });
  },
  
  // 头像加载失败处理
  onAvatarError(e) {
    console.error('头像加载失败', e);
    // 显示默认头像
    const userInfo = this.data.userInfo || {};
    
    this.setData({
      'userInfo.avatar': '', // 清空头像URL，会自动启用默认头像
      avatarLoading: false
    });
    
    // 打印出错的头像URL用于调试
    console.log('加载失败的头像URL:', userInfo.avatar);
  },

  // 去支付订单
  goToPay(e) {
    // 检查e是否为有效的事件对象
    if (e && e.currentTarget) {
      // 安全地尝试阻止事件冒泡
      if (typeof e.stopPropagation === 'function') {
        e.stopPropagation();
      }
      
      const orderId = e.currentTarget.dataset.id;
      if (!orderId) {
        return;
      }
      
      wx.navigateTo({
        url: `/pages/order/payment/index?id=${orderId}`
      });
    } else {
      console.error('goToPay函数接收到无效的事件对象', e);
    }
  },
}) 